// 引入Express框架和Router用于创建路由
const express = require('express')
// 创建路由实例，用于定义和管理路由
const router = express.Router()
// 引入文件上传配置模块（包含multer的存储设置、文件过滤等配置）
const upload = require('../config/upload')
const fs = require('fs')
const path = require('path')
const Carousel = require('../models/Carousel') // 引入Carousel模型
const Mentorship = require('../models/Mentorship')
const Employment = require('../models/Employment')
const Education = require('../models/Education')
const Project = require('../models/Project')
const mongoose = require('mongoose')
const authMiddleware = require('../middlewares/auth')
/**
 * 首页路由 - 处理根路径GET请求
 * @param {Object} req - 请求对象（包含请求参数、请求头等信息）
 * @param {Object} res - 响应对象（用于返回响应数据和状态）
 */
router.get('/hello', (req, res) => {
  // 发送简单的文本响应
  res.status(200).send('Welcome to the Enterprise Website')
})

/**
 * 轮播图上传接口 - 处理POST请求
 * upload.array('file', 5):
 *   - 使用multer中间件处理多文件上传
 *   - 'file' 对应前端表单的字段名
 *   - 5 表示最多接收5个文件
 * 成功上传后返回文件路径列表
 */
router.post('/uploadCarousel', authMiddleware(), upload.array('file', 5), async (req, res) => {
  try {
    const files = req.files.map(file => {
      return {
        filePath: `/uploads/carousel/${file.filename}`,
        fileType: file.filename.split('.').pop(),
        fileName: file.filename.split('/').pop()
      }
    })
    const carouselList = await Carousel.insertMany(files)

    // 返回201 Created状态码和JSON格式响应
    res.status(201).json({
      message: '轮播图上传成功',
      files: carouselList // 返回上传的文件信息
    })
  } catch (err) {
    // 捕获并处理所有异常，返回500服务器错误状态码
    res.status(500).json({
      message: '文件上传处理失败',
      error: err.message // 仅在开发环境返回具体错误信息
    })
  }
})

// 轮播图删除接口 - 处理DELETE请求
router.post('/deleteCarousel', authMiddleware(), (req, res) => {
  // 从请求对象中获取要删除的文件路径
  const { fileId } = req.body
  if (!fileId) {
    return res.status(400).json({
      message: '文件ID不能为空'
    })
  }
  Carousel.findByIdAndDelete(fileId)
    .then(carousel => {
      if (!carousel) {
        return res.status(404).json({
          message: '文件不存在'
        })
      }
      // 删除文件（假设 carousel.filePath 存在并且是正确的路径）
      fs.unlinkSync(path.join(__dirname, '../uploads/carousel/', carousel.fileName))
      res.status(200).json({
        message: '删除成功'
      })
    })
    .catch(err => {
      console.error('Error occurred:', err)
      res.status(500).json({
        message: '删除失败'
      })
    })
})

// 轮播图列表接口 - 处理GET请求
router.get('/getCarouselList', async (req, res) => {
  try {
    // 从数据库中查询轮播图列表并按创建时间排序
    const carouselList = await Carousel.find().sort({ order: 1 })

    // 返回轮播图列表
    res.status(200).json({
      message: '轮播图列表获取成功',
      data: carouselList
    })
  } catch (err) {
    res.status(500).json({
      message: '获取轮播图列表失败',
      error: err.message
    })
  }
})

// 更新轮播图排序接口
/**
 * 更新轮播图排序接口
 * @api {POST} /updateCarouselOrder 更新轮播图顺序
 * @apiDescription 根据传入的轮播图ID数组，更新轮播图的显示顺序
 * @apiParam {String[]} orderedIds 轮播图ID数组，数组顺序即为新的显示顺序
 * @apiSuccess {String} message 操作成功信息
 * @apiError (400) {String} message 参数错误信息
 * @apiError (500) {String} message 服务器错误信息
 */
router.post('/updateCarouselOrder', authMiddleware(), async (req, res) => {
  try {
    const { orderedIds } = req.body

    if (!Array.isArray(orderedIds) || orderedIds.length === 0) {
      return res.status(400).json({
        message: 'orderedIds 必须是一个非空数组'
      })
    }

    // 直接批量更新，不使用事务
    const updatePromises = orderedIds.map((id, index) => {
      return Carousel.findByIdAndUpdate(id, { order: index + 1 })
    })

    await Promise.all(updatePromises)

    res.status(200).json({
      message: '轮播图排序更新成功'
    })
  } catch (err) {
    res.status(500).json({
      message: '更新轮播图排序失败',
      error: err.message
    })
  }
})

router.get('/getAllGuides', async (req, res) => {
  try {
    const { year, pageNum = 1, pageSize = 10 } = req.query
    const page = Math.max(parseInt(pageNum, 10) || 1, 1)
    const limit = Math.max(parseInt(pageSize, 10) || 10, 1)
    const skip = (page - 1) * limit

    // 1. 构造公共筛选条件
    const baseFilter = { isSuccessCase: 1 }
    if (year) {
      const y = parseInt(year, 10)
      baseFilter.year = y
    }

    // 2. 分别针对每张表查 _id + updatedAt
    const [mentorshipRaw, employmentRaw, educationRaw, projectRaw] = await Promise.all([
      Mentorship.find({ ...baseFilter })
        .select('_id updatedAt')
        .lean(),
      Employment.find({ ...baseFilter })
        .select('_id updatedAt')
        .lean(),
      Education.find({
        ...baseFilter,
        ...(year
          ? {
              admissionDate: {
                $gte: new Date(`${year}-01-01`),
                $lte: new Date(`${year}-12-31`)
              }
            }
          : {})
      })
        .select('_id updatedAt')
        .lean(),
      Project.find({ ...baseFilter })
        .select('_id updatedAt')
        .lean()
    ])

    // 3. 打标记、合并、排序
    const all = [
      ...mentorshipRaw.map(r => ({ ...r, type: 'mentorship' })),
      ...employmentRaw.map(r => ({ ...r, type: 'employment' })),
      ...educationRaw.map(r => ({ ...r, type: 'education' })),
      ...projectRaw.map(r => ({ ...r, type: 'project' }))
    ].sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt))

    const total = all.length
    const pageIds = all.slice(skip, skip + limit)

    if (pageIds.length === 0) {
      return res.status(200).json({
        message: '所有指导数据获取成功',
        data: [],
        total,
        pageNum: page,
        pageSize: limit,
        totalPages: Math.ceil(total / limit)
      })
    }

    // 4. 按 id 批量取完整数据
    const byType = {}
    pageIds.forEach(({ _id, type }) => {
      ;(byType[type] = byType[type] || []).push(_id)
    })

    const [mentorshipDocs, employmentDocs, educationDocs, projectDocs] = await Promise.all([
      Mentorship.find({ _id: { $in: byType.mentorship || [] } })
        .populate('files')
        .lean(),
      Employment.find({ _id: { $in: byType.employment || [] } })
        .populate('files')
        .lean(),
      Education.find({ _id: { $in: byType.education || [] } })
        .populate('files')
        .lean(),
      Project.find({ _id: { $in: byType.project || [] } })
        .populate('files')
        .lean()
    ])

    // 5. 拼成 map 方便重排，并保持正确的类型信息
    const map = new Map()
    // 为每个文档添加正确的类型标识
    mentorshipDocs.forEach(doc => map.set(doc._id.toString(), { ...doc, item_type: 'mentorship' }))
    employmentDocs.forEach(doc => map.set(doc._id.toString(), { ...doc, item_type: 'employment' }))
    educationDocs.forEach(doc => map.set(doc._id.toString(), { ...doc, item_type: 'education' }))
    projectDocs.forEach(doc => map.set(doc._id.toString(), { ...doc, item_type: 'project' }))

    // 6. 按原来顺序输出
    const data = pageIds.map(({ _id }) => map.get(_id.toString()))

    res.status(200).json({
      message: '所有指导数据获取成功',
      data,
      total,
      pageNum: page,
      pageSize: limit,
      totalPages: Math.ceil(total / limit)
    })
  } catch (err) {
    res.status(500).json({
      message: '获取指导数据失败',
      error: err.message
    })
  }
})

// 如果文档本身没有区分 type 的字段，可用最简单的办法推断
function inferType(doc) {
  if (doc.mentor) return 'mentorship'
  if (doc.company) return 'employment'
  if (doc.school) return 'education'
  return 'project'
}

// 导出路由实例，供上层模块使用
module.exports = router
